package service

import (
	"fmt"
	"ginchat/models"
	"ginchat/utils"
	"github.com/asaskevich/govalidator"
	"github.com/gin-gonic/gin"
	"github.com/gorilla/websocket"
	"math/rand"
	"net/http"
	"strconv"
	"time"
)

// GetUserList
// @Summary 所有用户
// @Tags 用户模块
// @Success 200 {string} json{"code", "message"}
// @Router /user/getUserList [get]
func GetUserList(c *gin.Context) {
	data := make([]*models.UserBasic, 10)
	data = models.GetUserList()

	c.JSON(200, gin.H{
		"code":    0, // 0成功 -1失败
		"message": "获取成功",
		"data":    data,
	})
}

// CreateUser
// @Summary 新增用户
// @Tags 用户模块
// @Param name query string false "用户名"
// @Param password query string false "密码"
// @Param repassword query string false "确认密码"
// @Success 200 {string} json{"code", "message"}
// @Router /user/createUser [get]
func CreateUser(c *gin.Context) {
	/**
	新建用户:
		需要根据输入的字段内容作为查询条件,看看能否查到已经注册的用户   如果已经被注册了,直接返回用户已经注册
	*/
	user := models.UserBasic{}
	user.Name = c.Query("name")
	password := c.Query("password")
	repassword := c.Query("repassword")

	//生成一个随机整数，并将其格式化为一个六位数，前面用零填充。
	salt := fmt.Sprintf("%06d", rand.Int31())

	data := models.FindUserByName(user.Name)
	if data.Name != "" {
		c.JSON(-1, gin.H{
			"code":    -1,
			"message": "用户名已注册",
			"data":    user,
		})
		return
	}

	if password != repassword {
		c.JSON(-1, gin.H{
			"code":    -1, // 0成功 -1失败
			"message": "两次密码不一致",
			"data":    user,
		})
		return
	}

	//user.PassWord = password
	user.PassWord = utils.MakePassword(password, salt)
	user.Salt = salt

	models.CreateUser(user)
	c.JSON(200, gin.H{
		"code":    0, // 0成功 -1失败
		"message": "新增用户成功",
		"data":    user,
	})
}

// DeleteUser
// @Summary 删除用户
// @Tags 用户模块
// @Param id query string false "id"
// @Success 200 {string} json{"code", "message"}
// @Router /user/deleteUser [get]
func DeleteUser(c *gin.Context) {
	user := models.UserBasic{}
	id, _ := strconv.Atoi(c.Query("id"))
	user.ID = uint(id)
	models.DeleteUser(user)

	c.JSON(200, gin.H{
		"code":    0, // 0成功 -1失败
		"message": "登录成功",
		"data":    user,
	})
}

// UpdateUser
// @Summary 修改用户			--摘要
// @Tags 用户模块		--模块
// @Param id formData string false "id"		--参数格式
// @Param name formData string false "name"
// @Param password formData string false "password"
// @Param phone formData string false "phone"
// @Param email formData string false "email"
// @Success 200 {string} json{"code", "message"}	--响应成功，从左到右分别为：状态码、参数类型、数据类型、注释
// @Failure	响应失败，从左到右分别为：状态码、参数类型、数据类型、注释
// @Router /user/updateUser [post]		--路由，从左到右分别为：路由地址，HTTP 方法
func UpdateUser(c *gin.Context) {
	user := models.UserBasic{}
	id, _ := strconv.Atoi(c.PostForm("id"))
	user.ID = uint(id)
	user.Name = c.PostForm("name")
	user.PassWord = c.PostForm("password")
	user.Phone = c.PostForm("phone")
	user.Email = c.PostForm("email")
	user.Phone = c.PostForm("phone")
	user.Email = c.PostForm("email")
	fmt.Println("update", user)

	_, err := govalidator.ValidateStruct(user)
	if err != nil {
		fmt.Println(err)
		c.JSON(200, gin.H{
			"code":    -1, // 0成功 -1失败
			"message": "修改参数不匹配!",
			"data":    user,
		})
	} else {
		models.UpdateUser(user)
		c.JSON(200, gin.H{
			"code":    0, // 0成功  -1失败
			"message": "修改用户成功!",
			"data":    user,
		})
	}

}

// FindUserByNameAndPwd
// @Summary 所有用户
// @Tags 用户模块
// @Param name query string false "用户名"
// @Param password query string false "密码"
// @Success 200 {string} json{"code", "message"}
// @Router /user/findUserByNameAndPwd [get]
func FindUserByNameAndPwd(c *gin.Context) {
	data := models.UserBasic{}

	name := c.Query("name")
	password := c.Query("password")
	user := models.FindUserByName(name)
	if user.Name == "" {
		c.JSON(200, gin.H{
			"code":    -1, // 0成功 -1失败
			"message": "该用户不存在",
			"data":    data,
		})
		return
	}

	pwd := utils.MakePassword(password, user.Salt)
	data = models.FindUserByNameAndPwd(name, pwd)

	flag := utils.ValidPassword(password, user.Salt, user.PassWord)
	if !flag {
		c.JSON(200, gin.H{
			"code":    -1, // 0成功 -1失败
			"message": "密码不正确",
			"data":    data,
		})
		return
	}
	data = models.FindUserByNameAndPwd(name, password)

	c.JSON(200, gin.H{
		"code":    0, // 0成功 -1失败
		"message": "登录成功",
		"data":    data,
	})
}

// 防止跨域站点伪造请求    创建一个websocket.Upgrader对象,其中跨域策略允许为true
var upGrade = websocket.Upgrader{
	CheckOrigin: func(r *http.Request) bool {
		return true
	},
}

func SendMeg(c *gin.Context) {
	//创建ws连接  参1:c.writer 参2:c.request 参3:nil
	ws, err := upGrade.Upgrade(c.Writer, c.Request, nil)
	if err != nil {
		fmt.Println(err)
		return
	}
	//defer 断开ws连接
	defer func(ws *websocket.Conn) {
		ws.Close()
	}(ws)

	//ws连接 c上下文
	MsgHandler(ws, c)
}

func MsgHandler(ws *websocket.Conn, c *gin.Context) {
	for {
		msg, err := utils.Subscribe(c, utils.PublishKey) //订阅PublishKey的消息
		if err != nil {
			fmt.Println(err)
		}

		fmt.Println("发送消息:", msg)

		tm := time.Now().Format("2006-01-02 15:04:05")
		m := fmt.Sprintf("[ws][%s]: %s", tm, msg)
		err = ws.WriteMessage(1, []byte(m)) //这里的写动作, 是往哪里写?

		if err != nil {
			fmt.Println(err)
		}
	}
}

func SendUserMeg(c *gin.Context) {
	models.Chat(c.Writer, c.Request)
}
